package chjob

import (
	"fmt"
	"math/rand"
	"sort"
)

func Zuoye_01() {
	fmt.Println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	// 1、看下面一段程序，回答问题
	s1 := make([]int, 3, 4)
	s2 := append(s1, 1)
	fmt.Printf("%v, %[1]p\n", s1)
	fmt.Printf("%v, %[1]p\n", s2)
	s2[0] = 2
	s2 = append(s2, 5)
	s2[1] = 33
	fmt.Printf("%v, %[1]p\n", s1)
	fmt.Printf("%v, %[1]p\n", s2)
	// 请问s1、s2内各有什么元素？ s1: [0, 0, 0]   s2:[0, 0, 0, 1]
	// s1修改一个元素会影响s2吗？s2修改一个元素会影响s1吗？
	// s1修改元素会影响s2，s1和s2共用底层数组，s1容量是4，s2在追加后元素后底层数组长度为4，不会发生数组的扩容复制，共用底层数组修改元素都会发生变化。s2修改元素也会影响s1，同理公用底层数组。
	// s2再增加一个元素会怎么样？
	// s2现在长度为4容量为4，再增加一个会导致底层数组进行扩容，重新开辟内存存放数组，数组地址发生变化，和s1不再共用一个底层数组，再修改s1时s2不再受受影响。
}

func Zuoye_02() {
	fmt.Println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
	// 2、有一个数组 [1,4,9,16,2,5,10,15]，生成一个新切片，要求新切片元素是数组相邻2项的和。
	array01 := [8]int{1, 4, 9, 16, 2, 5, 10, 15}
	silce01 := make([]int, 0, 7)
	fmt.Printf("%v\n", array01)
	for i := 1; i < len(array01); i++ {
		silce01 = append(silce01, array01[i-1]+array01[i])
	}
	fmt.Println(silce01)
}

func Zuoye_03() {
	// 3、数字重复统计
	// 随机产生100个整数
	// 数字的范围[-100, 100]
	// 降序输出这些生成的数字并打印其重复的次数

	// 生成silce
	silce01 := make([]int, 0, 100)
	for i := 0; i < 100; i++ {
		k := rand.Intn(201) - 100
		// fmt.Printf("%+v,%[1]T\n", k)
		silce01 = append(silce01, k)
	}
	// 生成map
	map01 := make(map[int]int)
	for _, i := range silce01 {
		if _, ok := map01[i]; ok {
			map01[i] = map01[i] + 1
		} else {
			map01[i] = 1
		}
	}
	// 排序输出
	sort.Sort(sort.Reverse(sort.IntSlice(silce01)))
	fmt.Printf("元素%-3v出现次数:%3d\n", silce01[0], map01[silce01[0]])
	for i := 1; i < len(silce01); i++ {
		if silce01[i-1] != silce01[i] {
			fmt.Printf("元素%-3v出现次数:%3d\n", silce01[i], map01[silce01[i]])
		}
	}
}

func Zuoye_04() {
	// 4、简述线性数据结构和哈希表优劣
	/*
		线性数据结构：一组元素的序列，有0个或多个元素组成。
			顺序表：开辟一片连续的内存结构按照顺序进行存储元素，例如数组，切片（底层使用数组存储元素）。
				优劣:顺序存储，可以使用索引快速访问，时间复杂度O(1),在尾部增加和删除元素效率较高，其他位置增加和删除需要调整数组结构，时间复杂度O(n)，增加位置后的元素需要向后移动，删除位置后的元素需要向前移动，数据量多的话较慢，开辟空间是固定的，元素放不下了需要进行数据整体迁移，效率慢。
			链接表：
				底层内存存储是分散的，元素通过指针手拉手链接，查找特定元素时间复杂度为O(n)，数据插入或删除时调整元素指针next和prev，时间复杂度和顺序表一样为O(n)。
		哈希表：
			存放k-v对，数据结构复杂，需要计算哈希放入不同的桶，查找、插入和删除高效，时间复杂度都是O(1)，可以根据扩容策略实现动态扩展，无序不适用顺序访问场景，key不能冲突。
	*/
}
